/**
 * 更新所有设计模式的Java示例代码
 */
const { MongoClient } = require('mongodb');
require('dotenv').config();

// MongoDB连接配置
let MONGODB_URI = process.env.MONGODB_URI || 'mongodb://gof23user:gof23password@localhost:27017/gof23-game';
// 如果是命令行参数提供的URI，优先使用
const args = process.argv.slice(2);
if (args.length > 0) {
  MONGODB_URI = args[0];
}

// 预定义的一些Java示例代码
const javaExamples = {
  'Singleton': `/**
 * 单例模式示例
 */
public class Singleton {
    // 私有静态实例
    private static Singleton instance;
    
    // 私有构造函数，防止外部实例化
    private Singleton() {
        // 初始化操作
    }
    
    // 公共静态方法提供全局访问点
    public static synchronized Singleton getInstance() {
        // 懒加载
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
    
    // 业务方法
    public void doSomething() {
        System.out.println("Singleton is doing something...");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 获取单例实例
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        
        // 验证两个引用指向同一对象
        System.out.println("是否是同一个实例: " + (singleton1 == singleton2));
        
        // 使用单例
        singleton1.doSomething();
    }
}`,

  'Factory Method': `/**
 * 工厂方法模式示例
 */
// 产品接口
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 创建者抽象类
abstract class Creator {
    // 工厂方法
    public abstract Product createProduct();
    
    // 使用产品的方法
    public void someOperation() {
        // 调用工厂方法创建产品
        Product product = createProduct();
        // 使用产品
        product.operation();
    }
}

// 具体创建者A
class ConcreteCreatorA extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体创建者B
class ConcreteCreatorB extends Creator {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用ConcreteCreatorA
        Creator creatorA = new ConcreteCreatorA();
        creatorA.someOperation();
        
        // 使用ConcreteCreatorB
        Creator creatorB = new ConcreteCreatorB();
        creatorB.someOperation();
    }
}`,
  'Facade': `/**
 * 外观模式示例
 */
// 子系统1
class Subsystem1 {
    public void operation1() {
        System.out.println("Subsystem1: 操作1");
    }
    
    public void operation2() {
        System.out.println("Subsystem1: 操作2");
    }
}

// 子系统2
class Subsystem2 {
    public void operation1() {
        System.out.println("Subsystem2: 操作1");
    }
    
    public void operation2() {
        System.out.println("Subsystem2: 操作2");
    }
}

// 子系统3
class Subsystem3 {
    public void operation1() {
        System.out.println("Subsystem3: 操作1");
    }
}

// 外观类
class Facade {
    private final Subsystem1 subsystem1;
    private final Subsystem2 subsystem2;
    private final Subsystem3 subsystem3;
    
    public Facade() {
        this.subsystem1 = new Subsystem1();
        this.subsystem2 = new Subsystem2();
        this.subsystem3 = new Subsystem3();
    }
    
    // 提供给客户端的简单接口
    public void operationA() {
        System.out.println("外观: 操作A");
        subsystem1.operation1();
        subsystem2.operation1();
        subsystem3.operation1();
    }
    
    public void operationB() {
        System.out.println("外观: 操作B");
        subsystem1.operation2();
        subsystem2.operation2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建外观
        Facade facade = new Facade();
        
        // 通过简单接口与复杂子系统交互
        facade.operationA();
        System.out.println("------------");
        facade.operationB();
    }
}`
};

// 连接数据库并更新设计模式示例代码
async function updatePatternSampleCodes() {
  let client;
  let updatedCount = 0;

  try {
    client = new MongoClient(MONGODB_URI);
    console.log('尝试连接到MongoDB:', MONGODB_URI);
    await client.connect();
    console.log('MongoDB 连接成功');
    
    const db = client.db();
    const patternsCollection = db.collection('patterns');
    
    // 获取所有设计模式
    const patterns = await patternsCollection.find().toArray();
    console.log(`找到 ${patterns.length} 个设计模式`);
    
    // 显示每个模式的名称和示例代码前50个字符
    patterns.forEach(pattern => {
      const codeSample = pattern.sampleCode ? 
          (pattern.sampleCode.length > 50 ? 
           pattern.sampleCode.substring(0, 50) + '...' : 
           pattern.sampleCode) : 
          '无示例代码';
      console.log(`模式: ${pattern.name}, 示例代码: ${codeSample}`);
    });
    
    for (const pattern of patterns) {
      // 如果示例代码是"..."或包含"..."，或者长度很短，则更新为默认的Java代码
      if (pattern.sampleCode === '...' || 
          (pattern.sampleCode && pattern.sampleCode.includes('...')) ||
          !pattern.sampleCode || 
          (pattern.sampleCode && pattern.sampleCode.length < 50)) {
        
        console.log(`需要更新模式 ${pattern.name} 的示例代码`);
        let defaultCode = javaExamples[pattern.name];
        
        if (!defaultCode) {
          // 如果找不到默认代码，生成一个
          console.log(`为 ${pattern.name} 生成默认Java代码`);
          defaultCode = generateDefaultJavaCode(pattern.name, pattern.category);
        }
        
        await patternsCollection.updateOne(
          { _id: pattern._id },
          { $set: { sampleCode: defaultCode } }
        );
        
        updatedCount++;
        console.log(`已更新 ${pattern.name} 的示例代码`);
      } else {
        console.log(`模式 ${pattern.name} 的示例代码已经OK，无需更新`);
      }
    }
    
    console.log(`共更新了 ${updatedCount} 个设计模式的示例代码`);
  } catch (err) {
    console.error('更新设计模式示例代码时出错:', err);
  } finally {
    if (client) await client.close();
  }
}

// 根据模式名称和类别生成默认的Java代码
function generateDefaultJavaCode(patternName, category) {
  // 移除名称中的空格
  const className = patternName.replace(/\s+/g, '');
  
  return `/**
 * ${patternName} 模式示例代码 (${category})
 */
public class ${className}Example {
    public static void main(String[] args) {
        System.out.println("这是 ${patternName} 模式的示例代码");
        
        // 创建相关对象
        ${className} instance = new ${className}();
        
        // 使用该模式
        instance.execute();
    }
}

class ${className} {
    public void execute() {
        System.out.println("执行 ${patternName} 模式的核心逻辑");
    }
}`;
}

// 执行更新
updatePatternSampleCodes().then(() => {
  console.log('脚本执行完成');
}).catch(err => {
  console.error('脚本执行出错:', err);
}); 